// $ANTLR 3.4 C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g 2013-02-27 21:42:49

  package practicaspl.doceuno;
  import java.util.Hashtable;
  


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalisisParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "BLANCO", "CARACTER", "COLON", "COMA", "COMENTARIO", "C_CORCHETE", "C_PAR", "DIGITO", "DIV", "IDENT", "IGUAL", "MAS", "MAYOR", "MENOR", "MENOS", "MULT", "NUEVA_LINEA", "NUMERO", "O_CORCHETE", "O_PAR", "REAL", "SEMICOLON", "STRING", "TABULADOR", "CALL", "FUNC", "ID", "INSTRS", "LISTA_INST", "UNARIO"
    };

    public static final int EOF=-1;
    public static final int BLANCO=4;
    public static final int CARACTER=5;
    public static final int COLON=6;
    public static final int COMA=7;
    public static final int COMENTARIO=8;
    public static final int C_CORCHETE=9;
    public static final int C_PAR=10;
    public static final int DIGITO=11;
    public static final int DIV=12;
    public static final int IDENT=13;
    public static final int IGUAL=14;
    public static final int MAS=15;
    public static final int MAYOR=16;
    public static final int MENOR=17;
    public static final int MENOS=18;
    public static final int MULT=19;
    public static final int NUEVA_LINEA=20;
    public static final int NUMERO=21;
    public static final int O_CORCHETE=22;
    public static final int O_PAR=23;
    public static final int REAL=24;
    public static final int SEMICOLON=25;
    public static final int STRING=26;
    public static final int TABULADOR=27;
    public static final int CALL=28;
    public static final int FUNC=29;
    public static final int ID=30;
    public static final int INSTRS=31;
    public static final int LISTA_INST=32;
    public static final int UNARIO=33;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public AnalisisParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalisisParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return AnalisisParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g"; }


      Hashtable tablavar = new Hashtable();
      
      private ArrayList<RecognitionException> errors = new ArrayList<RecognitionException>();
      public ArrayList<RecognitionException> getErrors() {
        return errors;
      }
      @Override
      public void reportError (RecognitionException e) {
         String msg = getErrorMessage(e, getTokenNames());
         System.err.println(msg);
         errors.add(e);


      }
      
      public List<CommonTree> functionDefinitions = new ArrayList<CommonTree>();


    public static class instrucciones_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "instrucciones"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:1: instrucciones : ( tipoentrada SEMICOLON )* EOF -> ^( INSTRS ( tipoentrada )* ) ;
    public final AnalisisParser.instrucciones_return instrucciones() throws RecognitionException {
        AnalisisParser.instrucciones_return retval = new AnalisisParser.instrucciones_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token SEMICOLON2=null;
        Token EOF3=null;
        AnalisisParser.tipoentrada_return tipoentrada1 =null;


        MiArbol SEMICOLON2_tree=null;
        MiArbol EOF3_tree=null;
        RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
        RewriteRuleSubtreeStream stream_tipoentrada=new RewriteRuleSubtreeStream(adaptor,"rule tipoentrada");
        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:15: ( ( tipoentrada SEMICOLON )* EOF -> ^( INSTRS ( tipoentrada )* ) )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:17: ( tipoentrada SEMICOLON )* EOF
            {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:17: ( tipoentrada SEMICOLON )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==IDENT||LA1_0==MENOS||(LA1_0 >= NUMERO && LA1_0 <= REAL)||LA1_0==ID) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:18: tipoentrada SEMICOLON
            	    {
            	    pushFollow(FOLLOW_tipoentrada_in_instrucciones107);
            	    tipoentrada1=tipoentrada();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_tipoentrada.add(tipoentrada1.getTree());

            	    SEMICOLON2=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_instrucciones109); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_SEMICOLON.add(SEMICOLON2);


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_instrucciones113); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_EOF.add(EOF3);


            // AST REWRITE
            // elements: tipoentrada
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (MiArbol)adaptor.nil();
            // 49:46: -> ^( INSTRS ( tipoentrada )* )
            {
                // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:49: ^( INSTRS ( tipoentrada )* )
                {
                MiArbol root_1 = (MiArbol)adaptor.nil();
                root_1 = (MiArbol)adaptor.becomeRoot(
                (MiArbol)adaptor.create(INSTRS, "INSTRS")
                , root_1);

                // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:49:58: ( tipoentrada )*
                while ( stream_tipoentrada.hasNext() ) {
                    adaptor.addChild(root_1, stream_tipoentrada.nextTree());

                }
                stream_tipoentrada.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "instrucciones"


    public static class tipoentrada_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "tipoentrada"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:51:1: tipoentrada : ( asignacion | expresion | funcion );
    public final AnalisisParser.tipoentrada_return tipoentrada() throws RecognitionException {
        AnalisisParser.tipoentrada_return retval = new AnalisisParser.tipoentrada_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        AnalisisParser.asignacion_return asignacion4 =null;

        AnalisisParser.expresion_return expresion5 =null;

        AnalisisParser.funcion_return funcion6 =null;



        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:51:13: ( asignacion | expresion | funcion )
            int alt2=3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==IDENT) ) {
                int LA2_1 = input.LA(2);

                if ( (LA2_1==IGUAL) ) {
                    alt2=1;
                }
                else if ( (LA2_1==O_PAR) ) {
                    int LA2_4 = input.LA(3);

                    if ( (LA2_4==NUMERO||LA2_4==REAL||LA2_4==ID) ) {
                        int LA2_5 = input.LA(4);

                        if ( (LA2_5==C_PAR) ) {
                            int LA2_6 = input.LA(5);

                            if ( (LA2_6==IGUAL) ) {
                                alt2=3;
                            }
                            else if ( (LA2_6==DIV||LA2_6==MAS||(LA2_6 >= MENOS && LA2_6 <= MULT)||LA2_6==SEMICOLON) ) {
                                alt2=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 2, 6, input);

                                throw nvae;

                            }
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 2, 5, input);

                            throw nvae;

                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 2, 4, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA2_0==MENOS||(LA2_0 >= NUMERO && LA2_0 <= REAL)||LA2_0==ID) ) {
                alt2=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;

            }
            switch (alt2) {
                case 1 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:51:15: asignacion
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_asignacion_in_tipoentrada130);
                    asignacion4=asignacion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, asignacion4.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:51:28: expresion
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_expresion_in_tipoentrada134);
                    expresion5=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion5.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:51:40: funcion
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_funcion_in_tipoentrada138);
                    funcion6=funcion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, funcion6.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "tipoentrada"


    public static class asignacion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "asignacion"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:53:1: asignacion : IDENT IGUAL ^ expresion ;
    public final AnalisisParser.asignacion_return asignacion() throws RecognitionException {
        AnalisisParser.asignacion_return retval = new AnalisisParser.asignacion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT7=null;
        Token IGUAL8=null;
        AnalisisParser.expresion_return expresion9 =null;


        MiArbol IDENT7_tree=null;
        MiArbol IGUAL8_tree=null;

        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:53:12: ( IDENT IGUAL ^ expresion )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:53:14: IDENT IGUAL ^ expresion
            {
            root_0 = (MiArbol)adaptor.nil();


            IDENT7=(Token)match(input,IDENT,FOLLOW_IDENT_in_asignacion146); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENT7_tree = 
            (MiArbol)adaptor.create(IDENT7)
            ;
            adaptor.addChild(root_0, IDENT7_tree);
            }

            IGUAL8=(Token)match(input,IGUAL,FOLLOW_IGUAL_in_asignacion148); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IGUAL8_tree = 
            (MiArbol)adaptor.create(IGUAL8)
            ;
            root_0 = (MiArbol)adaptor.becomeRoot(IGUAL8_tree, root_0);
            }

            pushFollow(FOLLOW_expresion_in_asignacion151);
            expresion9=expresion();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion9.getTree());

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "asignacion"


    public static class funcion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "funcion"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:55:1: funcion : IDENT O_PAR parametro C_PAR IGUAL expresion -> ^( FUNC IDENT parametro expresion ) ;
    public final AnalisisParser.funcion_return funcion() throws RecognitionException {
        AnalisisParser.funcion_return retval = new AnalisisParser.funcion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token IDENT10=null;
        Token O_PAR11=null;
        Token C_PAR13=null;
        Token IGUAL14=null;
        AnalisisParser.parametro_return parametro12 =null;

        AnalisisParser.expresion_return expresion15 =null;


        MiArbol IDENT10_tree=null;
        MiArbol O_PAR11_tree=null;
        MiArbol C_PAR13_tree=null;
        MiArbol IGUAL14_tree=null;
        RewriteRuleTokenStream stream_IDENT=new RewriteRuleTokenStream(adaptor,"token IDENT");
        RewriteRuleTokenStream stream_O_PAR=new RewriteRuleTokenStream(adaptor,"token O_PAR");
        RewriteRuleTokenStream stream_IGUAL=new RewriteRuleTokenStream(adaptor,"token IGUAL");
        RewriteRuleTokenStream stream_C_PAR=new RewriteRuleTokenStream(adaptor,"token C_PAR");
        RewriteRuleSubtreeStream stream_parametro=new RewriteRuleSubtreeStream(adaptor,"rule parametro");
        RewriteRuleSubtreeStream stream_expresion=new RewriteRuleSubtreeStream(adaptor,"rule expresion");
        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:55:8: ( IDENT O_PAR parametro C_PAR IGUAL expresion -> ^( FUNC IDENT parametro expresion ) )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:55:10: IDENT O_PAR parametro C_PAR IGUAL expresion
            {
            IDENT10=(Token)match(input,IDENT,FOLLOW_IDENT_in_funcion158); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENT.add(IDENT10);


            O_PAR11=(Token)match(input,O_PAR,FOLLOW_O_PAR_in_funcion160); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_O_PAR.add(O_PAR11);


            pushFollow(FOLLOW_parametro_in_funcion162);
            parametro12=parametro();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_parametro.add(parametro12.getTree());

            C_PAR13=(Token)match(input,C_PAR,FOLLOW_C_PAR_in_funcion164); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_C_PAR.add(C_PAR13);


            IGUAL14=(Token)match(input,IGUAL,FOLLOW_IGUAL_in_funcion166); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IGUAL.add(IGUAL14);


            pushFollow(FOLLOW_expresion_in_funcion168);
            expresion15=expresion();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_expresion.add(expresion15.getTree());

            // AST REWRITE
            // elements: expresion, IDENT, parametro
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (MiArbol)adaptor.nil();
            // 55:54: -> ^( FUNC IDENT parametro expresion )
            {
                // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:55:57: ^( FUNC IDENT parametro expresion )
                {
                MiArbol root_1 = (MiArbol)adaptor.nil();
                root_1 = (MiArbol)adaptor.becomeRoot(
                (MiArbol)adaptor.create(FUNC, "FUNC")
                , root_1);

                adaptor.addChild(root_1, 
                stream_IDENT.nextNode()
                );

                adaptor.addChild(root_1, stream_parametro.nextTree());

                adaptor.addChild(root_1, stream_expresion.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving

                functionDefinitions.add(((MiArbol)retval.tree));
              
        }
        return retval;
    }
    // $ANTLR end "funcion"


    public static class numero_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "numero"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:60:1: numero : ( NUMERO | REAL );
    public final AnalisisParser.numero_return numero() throws RecognitionException {
        AnalisisParser.numero_return retval = new AnalisisParser.numero_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token set16=null;

        MiArbol set16_tree=null;

        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:60:8: ( NUMERO | REAL )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:
            {
            root_0 = (MiArbol)adaptor.nil();


            set16=(Token)input.LT(1);

            if ( input.LA(1)==NUMERO||input.LA(1)==REAL ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (MiArbol)adaptor.create(set16)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "numero"


    public static class parametro_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "parametro"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:62:1: parametro : ( ID | NUMERO | REAL );
    public final AnalisisParser.parametro_return parametro() throws RecognitionException {
        AnalisisParser.parametro_return retval = new AnalisisParser.parametro_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token set17=null;

        MiArbol set17_tree=null;

        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:62:11: ( ID | NUMERO | REAL )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:
            {
            root_0 = (MiArbol)adaptor.nil();


            set17=(Token)input.LT(1);

            if ( input.LA(1)==NUMERO||input.LA(1)==REAL||input.LA(1)==ID ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (MiArbol)adaptor.create(set17)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "parametro"


    public static class expresion_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expresion"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:1: expresion : exp_mult ( ( MAS ^| MENOS ^) exp_mult )* ;
    public final AnalisisParser.expresion_return expresion() throws RecognitionException {
        AnalisisParser.expresion_return retval = new AnalisisParser.expresion_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MAS19=null;
        Token MENOS20=null;
        AnalisisParser.exp_mult_return exp_mult18 =null;

        AnalisisParser.exp_mult_return exp_mult21 =null;


        MiArbol MAS19_tree=null;
        MiArbol MENOS20_tree=null;

        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:11: ( exp_mult ( ( MAS ^| MENOS ^) exp_mult )* )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:13: exp_mult ( ( MAS ^| MENOS ^) exp_mult )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_exp_mult_in_expresion225);
            exp_mult18=exp_mult();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_mult18.getTree());

            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:22: ( ( MAS ^| MENOS ^) exp_mult )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==MAS||LA4_0==MENOS) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:23: ( MAS ^| MENOS ^) exp_mult
            	    {
            	    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:23: ( MAS ^| MENOS ^)
            	    int alt3=2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0==MAS) ) {
            	        alt3=1;
            	    }
            	    else if ( (LA3_0==MENOS) ) {
            	        alt3=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 3, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt3) {
            	        case 1 :
            	            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:24: MAS ^
            	            {
            	            MAS19=(Token)match(input,MAS,FOLLOW_MAS_in_expresion229); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MAS19_tree = 
            	            (MiArbol)adaptor.create(MAS19)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MAS19_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:64:29: MENOS ^
            	            {
            	            MENOS20=(Token)match(input,MENOS,FOLLOW_MENOS_in_expresion232); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MENOS20_tree = 
            	            (MiArbol)adaptor.create(MENOS20)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MENOS20_tree, root_0);
            	            }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_mult_in_expresion236);
            	    exp_mult21=exp_mult();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_mult21.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expresion"


    public static class exp_mult_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_mult"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:1: exp_mult : exp_base ( ( MULT ^| DIV ^) exp_base )* ;
    public final AnalisisParser.exp_mult_return exp_mult() throws RecognitionException {
        AnalisisParser.exp_mult_return retval = new AnalisisParser.exp_mult_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MULT23=null;
        Token DIV24=null;
        AnalisisParser.exp_base_return exp_base22 =null;

        AnalisisParser.exp_base_return exp_base25 =null;


        MiArbol MULT23_tree=null;
        MiArbol DIV24_tree=null;

        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:10: ( exp_base ( ( MULT ^| DIV ^) exp_base )* )
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:12: exp_base ( ( MULT ^| DIV ^) exp_base )*
            {
            root_0 = (MiArbol)adaptor.nil();


            pushFollow(FOLLOW_exp_base_in_exp_mult246);
            exp_base22=exp_base();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_base22.getTree());

            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:21: ( ( MULT ^| DIV ^) exp_base )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==DIV||LA6_0==MULT) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:22: ( MULT ^| DIV ^) exp_base
            	    {
            	    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:22: ( MULT ^| DIV ^)
            	    int alt5=2;
            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0==MULT) ) {
            	        alt5=1;
            	    }
            	    else if ( (LA5_0==DIV) ) {
            	        alt5=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 5, 0, input);

            	        throw nvae;

            	    }
            	    switch (alt5) {
            	        case 1 :
            	            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:23: MULT ^
            	            {
            	            MULT23=(Token)match(input,MULT,FOLLOW_MULT_in_exp_mult250); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            MULT23_tree = 
            	            (MiArbol)adaptor.create(MULT23)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(MULT23_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:66:29: DIV ^
            	            {
            	            DIV24=(Token)match(input,DIV,FOLLOW_DIV_in_exp_mult253); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            DIV24_tree = 
            	            (MiArbol)adaptor.create(DIV24)
            	            ;
            	            root_0 = (MiArbol)adaptor.becomeRoot(DIV24_tree, root_0);
            	            }

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_exp_base_in_exp_mult257);
            	    exp_base25=exp_base();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp_base25.getTree());

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_mult"


    public static class exp_base_return extends ParserRuleReturnScope {
        MiArbol tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exp_base"
    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:68:1: exp_base : ( MENOS ^ numero | parametro | O_PAR ! expresion C_PAR !| O_CORCHETE expresion C_CORCHETE -> ^( UNARIO expresion ) | IDENT O_PAR parametro C_PAR -> ^( CALL IDENT parametro ) );
    public final AnalisisParser.exp_base_return exp_base() throws RecognitionException {
        AnalisisParser.exp_base_return retval = new AnalisisParser.exp_base_return();
        retval.start = input.LT(1);


        MiArbol root_0 = null;

        Token MENOS26=null;
        Token O_PAR29=null;
        Token C_PAR31=null;
        Token O_CORCHETE32=null;
        Token C_CORCHETE34=null;
        Token IDENT35=null;
        Token O_PAR36=null;
        Token C_PAR38=null;
        AnalisisParser.numero_return numero27 =null;

        AnalisisParser.parametro_return parametro28 =null;

        AnalisisParser.expresion_return expresion30 =null;

        AnalisisParser.expresion_return expresion33 =null;

        AnalisisParser.parametro_return parametro37 =null;


        MiArbol MENOS26_tree=null;
        MiArbol O_PAR29_tree=null;
        MiArbol C_PAR31_tree=null;
        MiArbol O_CORCHETE32_tree=null;
        MiArbol C_CORCHETE34_tree=null;
        MiArbol IDENT35_tree=null;
        MiArbol O_PAR36_tree=null;
        MiArbol C_PAR38_tree=null;
        RewriteRuleTokenStream stream_O_CORCHETE=new RewriteRuleTokenStream(adaptor,"token O_CORCHETE");
        RewriteRuleTokenStream stream_IDENT=new RewriteRuleTokenStream(adaptor,"token IDENT");
        RewriteRuleTokenStream stream_O_PAR=new RewriteRuleTokenStream(adaptor,"token O_PAR");
        RewriteRuleTokenStream stream_C_CORCHETE=new RewriteRuleTokenStream(adaptor,"token C_CORCHETE");
        RewriteRuleTokenStream stream_C_PAR=new RewriteRuleTokenStream(adaptor,"token C_PAR");
        RewriteRuleSubtreeStream stream_parametro=new RewriteRuleSubtreeStream(adaptor,"rule parametro");
        RewriteRuleSubtreeStream stream_expresion=new RewriteRuleSubtreeStream(adaptor,"rule expresion");
        try {
            // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:68:10: ( MENOS ^ numero | parametro | O_PAR ! expresion C_PAR !| O_CORCHETE expresion C_CORCHETE -> ^( UNARIO expresion ) | IDENT O_PAR parametro C_PAR -> ^( CALL IDENT parametro ) )
            int alt7=5;
            switch ( input.LA(1) ) {
            case MENOS:
                {
                alt7=1;
                }
                break;
            case NUMERO:
            case REAL:
            case ID:
                {
                alt7=2;
                }
                break;
            case O_PAR:
                {
                alt7=3;
                }
                break;
            case O_CORCHETE:
                {
                alt7=4;
                }
                break;
            case IDENT:
                {
                alt7=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:68:12: MENOS ^ numero
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    MENOS26=(Token)match(input,MENOS,FOLLOW_MENOS_in_exp_base267); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    MENOS26_tree = 
                    (MiArbol)adaptor.create(MENOS26)
                    ;
                    root_0 = (MiArbol)adaptor.becomeRoot(MENOS26_tree, root_0);
                    }

                    pushFollow(FOLLOW_numero_in_exp_base270);
                    numero27=numero();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, numero27.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:69:5: parametro
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    pushFollow(FOLLOW_parametro_in_exp_base277);
                    parametro28=parametro();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parametro28.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:70:5: O_PAR ! expresion C_PAR !
                    {
                    root_0 = (MiArbol)adaptor.nil();


                    O_PAR29=(Token)match(input,O_PAR,FOLLOW_O_PAR_in_exp_base284); if (state.failed) return retval;

                    pushFollow(FOLLOW_expresion_in_exp_base287);
                    expresion30=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expresion30.getTree());

                    C_PAR31=(Token)match(input,C_PAR,FOLLOW_C_PAR_in_exp_base289); if (state.failed) return retval;

                    }
                    break;
                case 4 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:71:5: O_CORCHETE expresion C_CORCHETE
                    {
                    O_CORCHETE32=(Token)match(input,O_CORCHETE,FOLLOW_O_CORCHETE_in_exp_base297); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_O_CORCHETE.add(O_CORCHETE32);


                    pushFollow(FOLLOW_expresion_in_exp_base299);
                    expresion33=expresion();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_expresion.add(expresion33.getTree());

                    C_CORCHETE34=(Token)match(input,C_CORCHETE,FOLLOW_C_CORCHETE_in_exp_base301); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_C_CORCHETE.add(C_CORCHETE34);


                    // AST REWRITE
                    // elements: expresion
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (MiArbol)adaptor.nil();
                    // 71:37: -> ^( UNARIO expresion )
                    {
                        // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:71:40: ^( UNARIO expresion )
                        {
                        MiArbol root_1 = (MiArbol)adaptor.nil();
                        root_1 = (MiArbol)adaptor.becomeRoot(
                        (MiArbol)adaptor.create(UNARIO, "UNARIO")
                        , root_1);

                        adaptor.addChild(root_1, stream_expresion.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 5 :
                    // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:72:5: IDENT O_PAR parametro C_PAR
                    {
                    IDENT35=(Token)match(input,IDENT,FOLLOW_IDENT_in_exp_base316); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENT.add(IDENT35);


                    O_PAR36=(Token)match(input,O_PAR,FOLLOW_O_PAR_in_exp_base318); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_O_PAR.add(O_PAR36);


                    pushFollow(FOLLOW_parametro_in_exp_base320);
                    parametro37=parametro();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_parametro.add(parametro37.getTree());

                    C_PAR38=(Token)match(input,C_PAR,FOLLOW_C_PAR_in_exp_base322); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_C_PAR.add(C_PAR38);


                    // AST REWRITE
                    // elements: IDENT, parametro
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (MiArbol)adaptor.nil();
                    // 72:33: -> ^( CALL IDENT parametro )
                    {
                        // C:\\Users\\Acer\\workspace\\doceuno\\src\\practicaspl\\doceuno\\AnalisisParser.g:72:36: ^( CALL IDENT parametro )
                        {
                        MiArbol root_1 = (MiArbol)adaptor.nil();
                        root_1 = (MiArbol)adaptor.becomeRoot(
                        (MiArbol)adaptor.create(CALL, "CALL")
                        , root_1);

                        adaptor.addChild(root_1, 
                        stream_IDENT.nextNode()
                        );

                        adaptor.addChild(root_1, stream_parametro.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (MiArbol)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (MiArbol)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exp_base"

    // Delegated rules


 

    public static final BitSet FOLLOW_tipoentrada_in_instrucciones107 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_SEMICOLON_in_instrucciones109 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_EOF_in_instrucciones113 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_asignacion_in_tipoentrada130 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expresion_in_tipoentrada134 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_funcion_in_tipoentrada138 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_asignacion146 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_IGUAL_in_asignacion148 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_expresion_in_asignacion151 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_funcion158 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_O_PAR_in_funcion160 = new BitSet(new long[]{0x0000000041200000L});
    public static final BitSet FOLLOW_parametro_in_funcion162 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_C_PAR_in_funcion164 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_IGUAL_in_funcion166 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_expresion_in_funcion168 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exp_mult_in_expresion225 = new BitSet(new long[]{0x0000000000048002L});
    public static final BitSet FOLLOW_MAS_in_expresion229 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_MENOS_in_expresion232 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_exp_mult_in_expresion236 = new BitSet(new long[]{0x0000000000048002L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult246 = new BitSet(new long[]{0x0000000000081002L});
    public static final BitSet FOLLOW_MULT_in_exp_mult250 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_DIV_in_exp_mult253 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_exp_base_in_exp_mult257 = new BitSet(new long[]{0x0000000000081002L});
    public static final BitSet FOLLOW_MENOS_in_exp_base267 = new BitSet(new long[]{0x0000000001200000L});
    public static final BitSet FOLLOW_numero_in_exp_base270 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parametro_in_exp_base277 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_O_PAR_in_exp_base284 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_expresion_in_exp_base287 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_C_PAR_in_exp_base289 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_O_CORCHETE_in_exp_base297 = new BitSet(new long[]{0x0000000041E42000L});
    public static final BitSet FOLLOW_expresion_in_exp_base299 = new BitSet(new long[]{0x0000000000000200L});
    public static final BitSet FOLLOW_C_CORCHETE_in_exp_base301 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_exp_base316 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_O_PAR_in_exp_base318 = new BitSet(new long[]{0x0000000041200000L});
    public static final BitSet FOLLOW_parametro_in_exp_base320 = new BitSet(new long[]{0x0000000000000400L});
    public static final BitSet FOLLOW_C_PAR_in_exp_base322 = new BitSet(new long[]{0x0000000000000002L});

}